package org.tri.swing;

import java.text.ParseException;
import javax.swing.JFormattedTextField;

/**
 * La clase {@code EditableFormattedLabel} utiliza como componente editor un
 * {@code JFormatedTextField} en lugar de un simple {@code JTextField}. Esto
 * permite realizar algunas comprobaciones sobre la edicion, previo a realizar
 * los cambios sobre el label.
 * @author kiira
 * @version 1.0, Feb 4, 2012
 */
public class EditableLabelFTF extends EditableLabelTF {

    /**
     * {@inheritDoc}
     */
    @Override
    protected String preCheck( String text ) {
        JFormattedTextField textField = 
        (JFormattedTextField)this.editableComponent;

        //intentamos setear el texto al text field. Si falla, el mismo se setea
        //a la string vacia para evitar inconsistencias
        try {            
            textField.setText( text );
            textField.commitEdit();
            text = textField.getValue().toString();

        } catch ( Exception ex ) {
            textField.setValue( null );
            text = "";

        }
        
        return text;

    }//end método preCheck

    /**
     * Devuelve el valor parseado por el {@code AbstractFormatter} del 
     * {@code JFormattedTextField}. La clase del mismo depende del tipo de
     * formatter utilizado.
     * @return valor parseado porel formatter.
     */
    public Object getValue() {
        Object value = null;

        JFormattedTextField textField = 
        (JFormattedTextField)this.editableComponent;

        //commiteamos previo a devolver el valor para asegurarnos de que es 
        //un valor válido
        try {
            textField.commitEdit();
            value = textField.getValue();

        } catch ( ParseException pEx ) {
            //ignore
        }

        return value;

    }//end método getValue

    /**
     * {@inheritDoc}
     */
    @Override
    public void makeEditable( ) {
        //si no se creo el componente, lo creamos para evitar fallos
        //mas adelante
        if ( editableComponent == null )
            editableComponent = new JFormattedTextField();

        super.makeEditable();

    }//end método makeEditable

    /**
     * Este método inicializa el componente editable a un 
     * {@code JFormattedTextField} que utiliza el
     * {@code AbstractFormatterFactory} indicado.
     * @param formatter formatter para el componente editable.
     */
    public void makeEditable( 
            JFormattedTextField.AbstractFormatterFactory formatter ) {
        editableComponent = new JFormattedTextField( formatter );

        makeEditable();

    }//end método makeEditable

    /**
     * {@inheritDoc}
     */
    @Override
    public void deactivateEditMode() {
        //solo lo desactivamos si está siendo editado.
        if ( !isBeingEdited() )
            return;

        //removemos el componente editable
        container.remove( editableComponent );

        //intentamos comittear el valor
        JFormattedTextField textField =
                            (JFormattedTextField)this.editableComponent;

        try {
            textField.commitEdit();

        } catch ( ParseException pEx ) {
            textField.setValue( null );

        }

        //obtenemos el valor y lo aplicamos
        Object value = textField.getValue();
        String newText = ( value != null ) ? value.toString() : "";
        applyEdition( newText );

        //reincorporamos el label al contenedor
        container.add( this, constraints );

        container.revalidate();
        container.repaint();

    }//end método deactivateEditMode

}//end clase EditableLabelFTF